import axios from 'axios'

// 创建axios实例
const apiClient = axios.create({
    baseURL: 'http://localhost:8000/api',
    timeout: 60000,
    headers: {
        'Content-Type': 'application/json'
    }
})

/**
 * 发送穿搭推荐请求（流式响应）
 * @param {string} query - 用户查询内容
 * @param {Function} onMessage - 流式数据回调
 * @param {Function} onComplete - 完成回调
 * @param {Function} onError - 错误回调
 */
export const getOutfitRecommendation = async (query, onMessage, onComplete, onError) => {
    try {
        // 创建AbortController用于超时控制
        const controller = new AbortController();
        const timeoutId = setTimeout(() => controller.abort(), 30000); // 30秒超时

        const response = await fetch('http://localhost:8000/api/users/recommend_outfit/', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
            },
            body: JSON.stringify({ query }),
            signal: controller.signal
        });

        clearTimeout(timeoutId);

        if (!response.ok) {
            if (response.status === 404) {
                throw new Error('API端点不存在，请检查后端服务是否启动');
            } else if (response.status === 500) {
                throw new Error('后端服务内部错误，请检查后端日志');
            } else {
                throw new Error(`HTTP错误: ${response.status} - ${response.statusText}`);
            }
        }

        const reader = response.body.getReader();
        const decoder = new TextDecoder();

        try {
            while (true) {
                const { done, value } = await reader.read();
                if (done) break;

                const chunk = decoder.decode(value);
                const lines = chunk.split('\n');

                for (const line of lines) {
                    if (line.startsWith('data: ')) {
                        const data = line.slice(6);
                        if (data === '[DONE]') {
                            onComplete();
                            return;
                        }
                        try {
                            const parsed = JSON.parse(data);
                            if (parsed.content) {
                                onMessage(parsed.content);
                            }
                            if (parsed.usage) {
                                onComplete(parsed.usage);
                            }
                            if (parsed.error) {
                                onError(parsed.error);
                            }
                        } catch (e) {
                            // 忽略解析错误
                            console.warn('解析响应数据失败:', e);
                        }
                    }
                }
            }
        } finally {
            reader.releaseLock();
        }
    } catch (error) {
        console.error('API调用失败:', error);
        
        if (error.name === 'AbortError') {
            onError('请求超时，请检查后端服务是否正常运行');
        } else if (error.message.includes('Failed to fetch')) {
            onError('无法连接到后端服务，请确保后端服务已启动 (http://localhost:8000)');
        } else if (error.message.includes('API端点不存在')) {
            onError('API端点不存在，请检查后端路由配置');
        } else {
            onError(error.message || '请求失败，请稍后重试');
        }
    }
}

/**
 * 获取用户对话历史
 * @param {string} username - 用户名
 * @returns {Promise<Array>} 对话历史数组
 */
export const getChatHistory = async (username) => {
    try {
        const response = await apiClient.get(`/users/chat_history/?username=${username}`)
        return response.data
    } catch (error) {
        console.error('获取对话历史失败：', error)
        if (error.code === 'ECONNREFUSED') {
            throw new Error('无法连接到后端服务，请确保后端服务已启动');
        }
        return []
    }
}

/**
 * 清空用户对话历史
 * @param {string} username - 用户名
 * @returns {Promise<Object>} 操作结果
 */
export const clearChatHistory = async (username) => {
    try {
        const response = await apiClient.post('/users/clear_history/', { username })
        return response.data
    } catch (error) {
        console.error('清空对话历史失败：', error)
        if (error.code === 'ECONNREFUSED') {
            throw new Error('无法连接到后端服务，请确保后端服务已启动');
        }
        throw new Error('清空历史记录失败，请稍后重试')
    }
}

/**
 * 创建用户资料
 * @param {Object} userData - 用户数据
 * @returns {Promise<Object>} 创建结果
 */
export const createUser = async (userData) => {
    try {
        const response = await apiClient.post('/users/create_user/', userData)
        return response.data
    } catch (error) {
        console.error('创建用户失败：', error)
        if (error.code === 'ECONNREFUSED') {
            throw new Error('无法连接到后端服务，请确保后端服务已启动');
        }
        throw new Error('创建用户失败，请稍后重试')
    }
}

/**
 * 测试后端连接
 * @returns {Promise<boolean>} 连接是否成功
 */
export const testBackendConnection = async () => {
    try {
        const response = await fetch('http://localhost:8000/api/', {
            method: 'GET',
            timeout: 5000
        });
        return response.ok;
    } catch (error) {
        console.error('后端连接测试失败:', error);
        return false;
    }
}

export default apiClient
